Info-Mac 4/Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso/Newton/Development/newt-devenv-22 Folder/NewtNews.txt

Text File | 1994-06-03 | 34KB | 691 lines

NewtNews.txt
S. Weyer

note: the text in this file has no substantive changes since the version
for Newt 2.1.  a few names, numbers and typos have been fixed.  see Newt.1st
(and change22.txt for registered users) for other information.

About Newt 2.2
a native environment for developing simple applications using NewtonScript, and
creating turtle-like graphics using gestures, buttons, and NS.

Keywords: object-oriented programming, application development environment,
NewtonScript, NTK, learning, graphics, mathematics, Logo.

Copyright S. Weyer 1993, 1994, All Rights Reserved.

Newt is shareware. It may be freely distributed via online services and
bulletin boards if it is unmodified and includes the file NewtNews.txt. It may
not be commercially bundled or redistributed on CD-ROM, floppy disk, PCMCIA,
networks or other media without my permission. Please continue reading for
help, examples, warnings and other information.

After several days of trial use, please register your copy by sending a check
($30 before 8/1/94; -- see Shareware and Freeware) to the author. Tap overview,
select About Newt, tap Save to save a Registration Form in Notepad. In return,
I will provide you with a 40+ page manual containing additional features and a
mini-tutorial on NewtonScript, source for additional modules/examples, and
priority in responding to requests.

Stephen Weyer
17 Timber Knoll Drive
Washington Crossing, PA 18977-1052
Internet: [e-mail]
America Online/eWorld/NewtonMail: SteveWeyer
AppleLink: WEYER.S

Revision History
2.2 (6/6/94):
+ support and examples for additional system prototypes and viewclasses
  (it now supports all prototypes and viewclasses described in NTK 1.0.1):
  protoRCheckbox, protoFilingButton, protoDrawer, protoDateExpando,
  protoPhoneExpando, protoActionButton, protoPrintFormat, protoKeyboard,
  protoKeypad, protoLabeledBatteryGauge, protoPicker, protoEndPoint,
  clView, clEditView, clGaugeView, clKeyboardView, clMonthView, clOutline,
  clParagraphView, clPictureView, clPolygonView, clRemoteView
+ a few other fixes/features (described in change22.txt for registered users)

2.1 (4/20/94):
+ reorganizes interface: Edit Methods moves to "main" view, turtle to Drawing
  Area; other cosmetic improvements
+ supports and documents additional system prototypes: protoBorder,
  protoCloseBox, protoDivider, protoFloater, protoFolderTab, protoGauge,
  protoGlance, protoLabelInputLine, protoLargeCloseBox, protoPictIndexer,
  protoPictRadioButton, protoPictureButton, protoRoll, protoRollBrowser,
  protoRollItem, protoSetClock, protoShowBar, protoStatus, protoStatusBar,
  protoTable, protoTableDef, protoTableEntry, protoTitle
+ supports user prototypes and subviews ("linked layouts")
+ handles low frame heap situations better
+ adds Color (penPattern) option for Newt drawing

2.0 (2/16/94):
+ adds initial support for creating interface objects and saving applications
+ new icon; "auto close"; separate RUNewt application for running, exchanging
  applications
+ rearranges/resizes interface for Newt Controls, Eval Controls, Code
  Templates, Edit Methods (continued)
+ moves samples to Expr button, overview accesses list of views
+ sets keyboard input to a default edit location (Eval field or method source)
+ saves folder for "newts" to/from Preferences; does not remove Preferences as in 1.1
+ improves access for large and larger numbers of method entries
+ adds visual feedback for Pen setting -- Newt grows/shrinks
+ adds support for Logo word and sentence operations

1.2 (12/93-2/94)
+ limited distribution beta releases; Happy Newt Year

1.1 (11/24/93):
+ saves Newt methods, screen snapshots and evaluation results as "newts"
  (notes) in Notepad, organized via the built-in folders
+ sends messages to single newt or to many newts
+ adds a Print?option, with results and errors printed to a popup scrolling Eval Log
+ eliminates the "do you want to add..." prompts during keyboard entry
+ streamlines NewtonScript editing via inserting code templates in Edit
  Methods (continued) and via selecting entire sample expressions for Eval field
+ recognizes line gesture to set Newt heading and to draw lines; drag to move Newt
+ draws more cleanly (clipping, refresh); adds "poof" animation for erase
+ simplifies interface for editing methods; scrolls methods
+ traps and reports errors
+ removes Preferences entry when Newt application is removed

1.0 (10/12/93)
+ initial release


Introduction

Learners or Programmers?
You can use Newt as
+ a pen-based "etch-a-sketch"
+ a Logo-like turtle-graphics environment
+ an introduction to NewtonScript and object-oriented programming
+ a construction tool for simple views and applications
You can get started by trying some of the simple examples outlined under Quick Tour.

Newt and Turtle
"Newton Turtle" and "NewtTurtle" seemed a bit too long, so I shortened its name
to Newt, given its amphibious similarity to its Logo cousin and also its
non-turtle uses. So that Newt can appeal to many families and orientations, it
is gender "newtral" (in order to reproduce more Newts, however, it has not
been "newtered"); users should probably not call themselves "newtists".

Newt and Newton
"Newt" is often used by the monosyllable-challenged to refer to a Newton. "Newt
is neat" could refer to the Newton itself and/or to this wonderful application
-- I will always mean the latter. Show Newt to your friends to help achieve
the worldwide goal of "Newt on every Newt"!

Newt and Notepad
Another name for Newt could have been "NewtPad" given its use of the Notepad
application for viewing, printing, etc. of "newt notes" (methods and screens)
or "newts" for short. One might imagine a future Newt as just a smart drawing
button available on the standard Notepad. In the meanwhile, Newt is a separate
application.

NewtonScript (NS) and Logo
In addition to using buttons and gestures, you can command Newt and build
application objects via NewtonScript (NS), which is Newton's built-in,
object-oriented (o-o) language. NS shares ancestry with dynamic o-o languages
like Smalltalk, Self, Common Lisp, and ObjectLogo. For more advanced users,
familiarity with o-o concepts and constructs would be useful; for others, Newt
should serve as a brief introduction to these ideas. For exploration of Newt's
"turtle personality", familiarity with Logo concepts and turtles would be
useful though not necessary. Although Newt does not "understand" any of the
Logo dialects directly, it does provide turtle commands, and an optional
module for manipulating Logo-style data structures, i.e., words and sentences.
Despite syntactic differences with Logo, you can borrow ideas and translate
code from Logo materials and books, e.g., Abelson & diSessa, books on
fractals, etc.

Newt in the News
Newt 1.0 received a positive review in the first issue of the (now defunct)
DoubleTap newsletter. Drafts of two articles are available via email:
exploring graphics via Newt's "turtle personality", and building applications
via Newt's application personality. Given the dynamic nature of the PDA
publication marketplace, it's unclear where and when these will appear.
_protoReality 1.3 -- the NANUG newsletter, available as a Newton book --
features an interview about Newt.

In other literary references, there is of course Shakespeare's famous drink
recipe: "eye of newt, ...". Tabloids will probably suggest a connection
between Newt and Elvis. This is likely, given Elvis' early career as a "lounge
lizard". To see proof of this (and ensure the proper mood for using Newt), you
can set the Country field of your Personal Preferences to Graceland (warning:
this "Easter Egg" may later interfere with dialing). A picture of a newt will
reappear briefly whenever you wakeup your Newton (this seems to have gone away
in the newest Newton ROMs; other wakeup pictures can be obtained by adding two
or three spaces after your Address). You should discount any allegations
suggesting any relation between Newt and Senator Newt Gingrich or football
great Knute Rockne. Finally, for crossword puzzle fans, "eft" is an old term
for "newt".

Newt and RUNewt and Newton ToolKit (NTK)
Newt allows you to write your own expressions and methods, and execute them
directly on your Newton. Newt 2.0 introduced rudimentary capabilities to
create dynamic views and stand-alone applications that can later be run or
transferred using RUNewt -- for further information, see RUNewt.txt. Users
interested in building small applications could consider Newt a portable
prototyper, or as a learning step toward building more complex, complete and
industrial-strength applications via Apple's desktop-based Newton ToolKit
(NTK). Since I provide little description of Newton syntax, other functions,
or curriculum ideas in this introductory file, I strongly recommend that you
stay reasonably close to the examples that I provide, register Newt to obtain
a more detailed manual and sample sources, wait for NS books to be published,
and/or buy the NTK and docs from APDA for $795. I also recommend PIE
Developers magazine.

Programming WARNING -- Newt and You
Exploring "mathematics microworlds" and doing problem solving by writing
programs are "powerful ideas" (Seymour Papert) and require some active
participation by you the learner -- taking risks and making mistakes. For
example, Newt allows you to execute arbitrary NewtonScript expressions. This
can be a formula for enlightenment or disaster. So, remember that this is your
Newton with your information and listen to your mother's advice about backing
up your system and hanging out with strange functions.

Using common sense in following examples and suggestions, and limiting yourself
to documented commands, you should reap many benefits and long hours of
enjoyment from using Newt. At the same time, "a little learning [about
programming] is a dangerous thing" (with apologies to Alexander Pope). I would
caution against experimenting with random functions or methods. "Gee, I wonder
what xxx does" might yield a simple error box, or it might zap a frame or soup
in your system.

At the same time, given the litigious nature of our society that yearns for
risk without responsibility, I feel compelled to add the following warning
(repeated in other variations several places later): >>> WARNING: USE THIS
PACKAGE AT YOUR OWN RISK! <<<

Shareware and Freeware
Newt is my first shareware offering; earlier, I distributed a freeware game
"PicoFermiBagels". I debated whether to cripple this version by not allowing
you to save any or many methods or to automatically quit after awhile if you
hadn't registered, but I decided that I'd rather spend my time figuring out
how to add new functionality rather than disable existing features.

Registered users receive a formatted manual including information about
additional methods, an introduction to NewtonScript, and selected source
examples. I welcome comments, suggestions and questions; I will respond as
time permits. Minor updates to the basic Newt package will generally be
free, especially if distributed over a network. However, I reserve the right
to charge additionally for major upgrades, for additional modules or other
services. The registration fee for Newt 2.2 is currently $30 (until 8/1/94)
-- "$35" for international users to cover currency fluctuation and
additional mailing cost. Checks preferred (no Visa yet). Current registered
users can request the latest manual for $5, a Mac or PC floppy with latest
release and examples for $5.

RUNewt is free to end-users; if you like it, I ask that you send email to my
kids (America Online: Krisbo and EllieJelly; internet: [e-mail],
[e-mail]), postcards, and/or other valuable tokens of appreciation.
Developers can contact me about invoking RUNewt from their applications, and
bundling the latest (or custom version) of RUNewt with their applications --
all for a small flat licensing fee. See RUNewt.txt for further info.

If after a few days of trial use, you find Newt useful and would like to
continue using it with a clear conscience and have the additional benefits
just mentioned, please stop procrastinating and register. I know this sounds
like a pledge break for National Public Television/Radio, but that's the kind
of user participation and support that shareware deserves and needs. If you're
still not ready to register, don't be afraid to send email -- to ask more
about what Newt already provides or tell me what it should have. Knowing users
are out there, with some occasional words of encouragement and praise, are
important. Money confirms that, covers some costs, and helps justify spending
a little more time on Newt in preference to other family or business pursuits.
To register, tap overview, select About Newt, then tap Save (in Eval Controls)
before exiting to create a registration form in your Notepad to print, email,
etc.

Where to Find Newt and RUNewt
Presumably, you have already obtained Newt or you would not be reading this. A
compressed file usually named newt-devenv-vv.sit or .hqx (vv = version number,
e.g., 2.2 = 22) should contain Newt-vv.pkg and NewtNews.txt; runewt-vv.sit or
.hqx should contain RUNewtvv.pkg and RUNewt.txt. You should find the most
recent versions on:

America Online(AOL): PDA:New Files (or PDA:Software Libraries:Newton)
Internet via anonymous ftp:
   + newton.uiowa.edu:pub/newton/software/app/
   + sumex-aim.stanford.edu(&mirror sites):info-mac/newton/app/
AppleLink: Newton:Newton User Discussions:Freeware, Shareware and Demos
Compuserve: GO NEWTON (DL 8)
Other: let me know where else you obtain it so that I can ensure that it is
current and complete.

Installation
I assume that
+ your online service (e.g., AOL, Compuserve) handles automatic file unpacking/
  conversion (or you are familiar with Binhex and Stuffit tools on PC or Mac)
+ you have a serial cable and Newton Connection Kit (NCK) or Package Express
  for Macintosh or Windows, or the freeware Newton Package Downloader for Mac
If not, contact me and I may be able to offer some help.



Newt Interface Guide

Quick Tour
Once you have installed and started Newt:
+ tap overview and select About Newt. You can tap Save (located in the bottom
  Eval Controls) to save a registration form to your Notepad. close About Newt.
+ to explore Newt's turtle personality, tap overview and select Newt Drawing,
  then select Newt Controls.
+ write a number into the input field to the right of Dist, e.g., 80. tap Dist.
+ write a number into the input field to the right of Deg, e.g., 90. tap Deg.
+ write a (small) number, e.g., 4, into the input field to the right of Times.
  tap Times.
+ tap Newt? checkbox. tap it again.
+ tap Erase. tap Home.
+ tap Expr and select an expression. maybe edit values for times, dist, deg.
  tap Eval button.
+ draw a picture that you like, tap Save (later check that folder in Notepad).
+ drag Newt to another location and Eval an expression again.
+ select and Eval :fourNewts() from the Expr list, then select and Eval
  another expression like :squiral(8,40)-- this demonstrates broadcasting
  messages to multiple Newts. Use a gesture on a specific newt. Send a message
  to the upper left newt, e.g., newt1:poly2(5,40,144,0)
+ to explore Newt's application personality, select and Eval :helloDemo0()
  from the Expr list. This is a trivial example of an application. You can
  write a number in the input field, tap on the About button, or evaluate an
  expression such as SetValue(hello.text1, 'text, "hello"),
  hello.button1:hide() or hello.button1:show(). If you have installed RUNewt,
  you can tap the Save button in Eval Controls when Hello Demo is on top, and
  then run or transfer your app later -- see RUNewt.txt for further info. To
  find out more about building applications in Newt, send me email for a copy
  of a draft article, or better yet, register to receive the manual and more
  examples.

The following sections cover the major interface areas of Newt -- the views
available by tapping overview (the dot between the two fixed scroll arrows at
the bottom of the screen).

Edit Methods (Main View)
This is the initial screen where you browse and edit object methods. Other
views (windows) are used for drawing, printing, building applications, and as
control palettes.

overview
Tapping the overview dot (between the fixed scroll arrows) pops up a list of
current views, containing built-in views such as About Newt, Newt Drawing and
Eval Log, palettes such as Code Templates, Eval Controls or Newt Controls,
RUNewt 2.2 (if installed), and any user-created applications, e.g., Hello
World.

scroll arrows
In Edit Methods (Main View) or Eval Log (if visible), the main text field
scrolls.

folder tab
Newt uses the folder label for organizing "newts" for Save in Edit Methods
(Main View), Newt Drawing, , Eval Log, and About Newt. Newt does not currently
provide a filing button or action button; however, you can look at,
reorganize, print, fax, beam etc. your saved newts (methods, screen snapshots,
print results, registration form) outside Newt in the Notepad application.
Newt "compiles" (i.e., makes an executable version of) methods found in the
current folder, and notes errors (if any) in Eval Log.

We will now cover the other palettes and views, and return to editing and
creating methods later under Edit Methods (continued).

Eval Controls
The following controls are found in a floating, draggable palette, located
initially at the bottom of Newt's screen: Eval field, Expr, keyboard icon,
Eval button, Print?, and Save. As a general rule, you will want to keep Eval
Controls always visible, rather than closing and re-opening it.

Eval field
This field can contain a short program in NewtonScript. Tap the Eval button to
execute it. Techniques for entering expressions include combinations of
+ handwriting -- not great, given the amount of punctuation needed
+ copy & drag text selections to/from the margin "clipboard"
+ tap the keyboard icon for a floating keyboard without "do you want to add" prompts
+ double-tap for the default alphanumeric keyboard and use extra spaces
  around NewtonScript punctuation to prevent spurious prompts
+ keyboards, e.g., KbdPro, or "reverse terminal emulators", e.g., Typomatica
  (Figgles Utils)
+ tapping Times in Newt Controls to fill in a standard for expression
+ selecting complete expressions from the Expr list
+ using the variable names times, dist and deg, so you can change numbers in
  the Times, Dist and Deg fields in Newt Controls rather than in the middle of
  the Eval field.
+ selecting partial expressions from the Code Templates palette

Expr
A popup list of sample expressions appears. If you select an expression, it
appears in the Eval field. You can then edit it, and/or tap the Eval button to
execute. Registered users can customize this list.

keyboard icon
This toggles (either shows or hides) a floating alphanumeric keyboard that does
not prompt for additions to the dictionary. You can double-tap in the Eval
field for the standard keyboard.

Eval button
Tap the Eval button to evaluate (compile and execute) the expression in Eval
field. The button remains highlighted during execution. During interruptible
methods, e.g., squiral2, it changes to Stop and you can tap it to terminate
execution. If you spell something incorrectly, or use incorrect parameters or
syntax, Eval Log (or a system error box) will appear with a somewhat cryptic
error message or code. Basically, you'll have to take a closer look at what
you wrote, take a look at the additional NewtonScript documentation (see
NewtonScript) or error codes (see Errors), edit it and try again.

WARNING: I DO NOT PROVIDE A GENERAL INTERRUPT CAPABILITY. SO, UNLESS YOU LIKE
USING THE MANUAL RESET BUTTON IN THE BACK, USE COMMON SENSE IN CHOOSING VALUES
FOR ITERATION, RECURSION OR DISTANCE THAT ARE NOT "TOO LARGE". I will
generally provide some reasonable values to try. Newt's default behavior is to
finish executing the entire expression before checking for user actions like
button taps. There is a facility provided in Newt to replace the NewtonScript
for iteration construct. This facility executes each step in the background,
allows you to interrupt Newt, and is covered in the manual.

Print?
If checked (default: no), the Eval Log view pops up with expression and results
after you tap the Eval button. Error messages will also appear regardless of
this setting.

Save
The current (top) view is saved, usually to the Notepad under the current
folder tab category. For Edit Methods (Main View), the method source, if
edited, is saved. For About Newt, a text registration form is saved. For Eval
Log, the current printed results are saved. For Newt Drawing, the current
drawing, if any, is saved . A user Application is saved to an application
soup, if RUNewt is installed. If the view is not recognized, Newt beeps.

Newt Drawing
Newt's drawing area appears when you select it from overview, use Newt
Controls, or evaluate an expression using drawing methods. You can use the
following gestures to operate on the Newt closest to the start of the gesture.
(You may have multiple Newts -- see :fourNewts() expression).
+ tap
Newt moves to location of pen using current Pen setting, preserving heading.
+ line
Newt sets heading to orientation (mod 45 degrees) of line. If Newt is already
headed in that direction, it draws a line of same length (rounded to mod 10)
of your gesture.
+ scrub
same as Erase
+ drag
Hold down on a Newt until you "hear a squeak and get a fat pen" (actually the
"hilite" gesture). Then, drag to a new location before lifting pen. Newt moves
to new location without drawing.

Use the Save button in Eval Controls to save the current drawing in the Notepad
under the current folder tab category. Newt currently "remembers" the current
drawing when you close and re-enter Newt Drawing.

Newt Controls
Select this floating, draggable palette via overview. It is located initially at
the top of Newt Drawing. and contains the following controls: Erase, Home,
Pen, Color, Newt?, Times button & field, Dist button & field, Deg button &
field. Like keyboards and Eval Controls, it can be dragged by its bottom
border.

Times
The value in this field (default: 0) can be used as a times variable in the
Eval field. The Times button uses this value to create an iteration, e.g., if
Times=4, Dist=40, Deg=90, tapping on Times tells Newt to :go(40) then
:turn(90) 4 times, i.e., making a square -- the NewtonScript is written to the
Eval field where it is executed immediately (and you can edit it later if you
like). Tap Deg to turn, then tap Times or the Eval button again to see what
happens.

Dist
The value in this field (default: 0) can be used as a dist variable in the Eval
field. The Dist button uses this value for distance, e.g., if Dist=20, tapping
on Dist tells Newt to :go(20), moving 20 in the "forward" direction, i.e.,
along Newt's current heading. This draws a line if Pen is non-zero. A negative
value for dist just means go "backward". To give you some idea of scale,
Newt's default drawing area on MessagePad is roughly 228x310 (on a MP100).
Newt clips at its drawing boundary.

Deg
The value in this field (default: 0) can be used as a deg variable in the Eval
field. The Deg button uses this value for degrees, e.g., if Deg=90, tapping on
Deg tells Newt to :turn(90), turning right (clockwise) by 90 degrees. A
negative value just means turn left. Newt will "mod" your number to prevent
dizziness.

Erase
Newt erases drawing area, and remains with same position, heading and pen.

Home
Newt teleports to center, sets heading to 0 ("up"), preserving pen setting but
without drawing.

Pen
Newt sets pen thickness used in drawing (default: 1) and grows or shrinks in
size. 0 means Newt just moves (no line)

Color
Newt sets pen pattern used in drawing (default: black). Currently, this color
is not available in saved Notepad drawings (everything is black).

Newt?
If checked (default: yes), Newt appears with its tip at current x,y position,
pointing in current direction, and "xor-ed" so that it does not interfere with
drawing.

About Newt
Select this via overview. Tap Save in Eval Controls to create a registration
form in Notepad under the current category (see folder tab) for later
printing, mailing, etc.

Code Templates
This is a separate floating, draggable palette accessible via overview, located
initially on the right hand side of the screen. This can be used for Eval
field, but is most useful for method source in Edit Methods (Main View). As
you select items from the text list, a template is inserted into your current
method. Customizing this list is described in the manual.

Eval Log
See earlier comments under folder tab, scroll arrows, Print? and Save.

RUNewt 2.2
If you have RUNewt installed on your Newton, it will appear in overview, where
you can select it in order to run earlier Newt-created applications -- see
RUNewt.txt for further info.

Your Applications
overview also contains the titles of applications you are currently developing
within Newt, based on source methods. Once you Save the application as a frame
object, it is available separately via RUNewt.


Edit Methods (continued)
We now complete coverage of the interface by returning toEdit Methods (Main
View).

method names
A "picker" at the top preceded by a diamond contains methods defined in current
folder (see folder tab). You can also select New at the top of the menu to
create a default template.

method source
Like the Eval field, you can use handwriting, copy & drag and keyboards to edit
your method. In addition, you can copy an entire existing method by changing
its name. The only format requirement is that the method name occur on the
first line, and be followed immediately on the next line by func.

For example, here is source for your own implementation of mypoly:
mypoly
func (nsides,len)
// make a polygon of <nsides>
// each side is <len> length
// this computes angle <ang>
if nsides=0
then :beep ()
else begin
    local i,ang := 360/nsides;
    for i:=1 to nsides
    do begin
        :go (len); :turn (ang);
    end;
end

You could then invoke this method in the Eval field, e.g., :mypoly(5,75). Or, a
method can be as simple as:
fd
func(distance)
// forward
:go(distance)

Revert
If you have unsaved changes, the Revert button appears. Tap it to return to the
last version saved of the original method, or for New, to the basic template.

Save
Assuming that the method name is valid, does not conflict with a pre-defined
"system" method, and successfully compiles, the method source is saved
(created or updated) as a "newt" (i.e., text Note) in the current folder.
Errors, if any, are noted in Eval Log. Newt saves only valid sources. So, if
you cannot figure out a compile error from the cryptic message, you could
either Revert to the earlier version, or comment out offending code (precede
individual lines with //, or wrap a section with /* <lines of code> */), so
that you can Save for now, get on with your life, and look at it later.

Preferences
Newt saves your preferences for Pen, Color, Newt?, Print? and folder tab
category in a small "system soup" frame so that these persist across Newt
sessions. Should you no longer need Newt, you can remove this preferences
frame via a soup utility.

NewtonScript
Syntax
If you have already tried out the examples outlined in the earlier Interface
Quick Tour, tapped on the example expressions under Expr, and looked at the
earlier mypoly example, then you should have a rough idea of what the
NewtonScript (NS) syntax is like and several of Newt's commands. In NS,
programs or scripts are defined as "methods" on objects. Methods describe an
object's behavior or actions. Objects in NS are called "frames" (perhaps they
should have been called "newtrons"), which "inherit" attributes and behavior
from other frames, usually called "prototypes". Newt is a prototype or kind of
view. You tell Newt to do things by sending it a "message", e.g., go. This
message consists of a frame (Newt implicitly), a colon (:) separator, the
method name, and parentheses with zero or more parameters (values for
variables) separated by commas. For example, :go(50). A frame also has "slots"
(named attributes) that contain values that you can access, such as times,
dist, and deg. You can just use the slot name if it can be found via
inheritance, or frame.slot if you want to be more specific.

WARNING: IF YOU USE OTHER SYSTEM FRAMES, METHODS, AND FUNCTIONS BEYOND THE ONES
I HAVE DESCRIBED HERE AND IN EXAMPLE FILES, YOU DO SO AT YOUR OWN RISK.

For further information on NewtonScript syntax and view frame slots and
methods, NTK from APDA includes manuals, and other books will be published.
The Newt Manual provides a brief summary of syntax and functions, along with
additional Newt methods for registered users.

Errors
In the unlikely event that a system box pops up with a cryptic error code
during Eval or Save, check the following partial list of common error codes,
and see if there might be something missing or extra in one of your values or
expressions.

Table 1: Common Error Codes
Code
Description
-8007
syntax error (from compiler)
-48404
expected a number
-48402
expected an integer
-48803
wrong number of arguments
-48807
undefined variable
-48809
undefined method
1627052
divide by zero

There is a Newton book (newton.uiowa.edu/newton/software/books/error-book.hqx)
that lists errors from the NTK docs. If you have a Macintosh, the Newton
LowDown DA (newton.uiowa.edu/newton/misc/lowdown-da.hqx) may be useful.

Things to try: check your syntax against those in examples, check spelling for
method and variable names, missing or extra punctuation, garbage from stray
gestures, check number and type of arguments (e.g., float vs. integer), and in
general use your "newtle". If you think it's really a problem with Newt, send
me mail describing what you had entered, and I'll try to respond asap.

Newt Methods
In addition to providing basic coverage of NewtonScript syntax and some
built-in functions, the manual documents more than 40 methods for creating
applications, customizing Newt, drawing with it, and accessing other system
functionality. Description and examples of specific system prototypes are
provided in separate files. I have divided Newt methods into two categories:
Application and General Methods, and Drawing Methods. NewtNewt.txt lists only
several simple drawing methods.

:go(distance)
Newt moves distance from current location, forward if distance is positive,
backward if negative. If Pen is a number, Newt draws a line. Newt just clips
the line and disappears if you command it to go outside.

:home()
Newt moves to center, heads up, ignoring but preserving current Pen setting.

:pendown()
sets Newt's pen down.

:penup()
sets Newt's pen up.

:poly(sides,len)
Newt draws a polygon, e.g., :poly(6,50) is a hexagon. :poly(times,dist) uses
the edit fields in Newt Controls. A sample source was provided as an example
under Edit Methods (continued).

:turn(degrees)
Newt turns degrees relative to current heading: if positive, turns Newt to
right, negative to left.

Possible Next Steps
There are many features and fixes that would be nice to have. However, there
are also design trade-offs, especially given the MessagePad's and my
constraints. So, help me figure out:
+ where can it go on the screen?
+ is it worth the extra memory space or implementation time?
+ can it take advantage of existing Newton mechanisms or metaphors?

For example:
+ resizable views (hooks are in there; need better system support)
+ save applications as "real" Newton packages (need docs), access via Extras
+ more application protos; palette for app objects with interface support for
  drag, edit, etc.
+ online tutorial/help (on Mac as a FrameViewer or DocViewer file; on Newton as
  a book)
+ add filing and action buttons (reproduce Notepad functionality)?
+ better drag gesture; other gestures for drawing; undo support for drawing?
+ use Newt as a wireless remote LegoLogo controller
+ allow more customization of Newt environment, save more to Preferences?
+ more tutorial information, graphic and application examples?

Personal History
I first implemented a screen turtle on an IMLAC display computer, accessed from
BBN Logo on a DEC PDP-10 at Stanford circa 1973. Subsequently, I implemented
other versions in Lisp, and used others in Smalltalk and ObjectLogo. My
long-time interests in children, learning and programming environments, plus
two small NTK examples, Dot2Dot and InspectorGadget, with a little creative
juxtaposition, started me down this path. Experience with using and
implementing object-oriented browsers and toolkits in Smalltalk and Lisp and
numerous user requests led to the Newt 2.0 enhancements to support application
development. When I am not working on Newt at home or trying to have a life, I
am consulting, currently for pharmaceutical companies, on "enabling
technologies", in particular, pen-based systems.

Credits
Newt 2.2 was created with NTK 1.0.1. Newton and Newton ToolKit are trademarks
of Apple Computer. Kudos to Apple for creating an exciting product (Newton),
and powerful object-oriented language (NewtonScript) and development
environment (NTK). I look forward to new versions of NTK, documentation and
examples.

My family contributed the evening and weekend time for me to explore this;
Ellie and Kristina helped with testing, Maria with proofreading. Finally,
thanks to the early users and beta testers who have given me feedback and
encouragement. I hope that Newt can continue to evolve into an environment
that meets your needs.